GraphQL Föderáció: Schema Stitching - Részletes útmutató

A modern alkalmazásfejlesztés folyamatosan fejlődő világában a skálázható és karbantartható architektúrák iránti igény kiemelkedővé vált. A mikroszolgáltatások, eredendő modularitásukkal és független telepíthetőségükkel, népszerű megoldásként jelentek meg. Számos mikroszolgáltatás kezelése azonban bonyodalmakat okozhat, különösen, ha egységes API-t kell biztosítani a kliensalkalmazások számára. Itt lép a képbe a GraphQL Föderáció, és különösen a Schema Stitching.

Mi az a GraphQL Föderáció?

A GraphQL Föderáció egy hatékony architektúra, amely lehetővé teszi egyetlen, egységes GraphQL API létrehozását több mögöttes GraphQL szolgáltatásból (gyakran mikroszolgáltatásokat képviselve). Lehetővé teszi a fejlesztők számára, hogy több különböző szolgáltatáson keresztül kérdezzenek le adatokat, mintha azok egyetlen gráfot alkotnának, egyszerűsítve a kliensélményt és csökkentve a komplex vezénylési logika szükségességét a kliensoldalon.

A GraphQL Föderációnak két fő megközelítése van:

• Schema Stitching: Ez több GraphQL séma egyetlen, egységes sémává való egyesítését jelenti az átjáró (gateway) rétegen. Ez egy korábbi megközelítés, amely könyvtárakra támaszkodik a sémák kombinálásának és a lekérdezések delegálásának kezelésére.
• Apollo Föderáció: Ez egy újabb és robusztusabb megközelítés, amely egy deklaratív séma nyelvet és egy dedikált lekérdezés-tervezőt használ a föderációs folyamat kezelésére. Fejlett funkciókat kínál, mint például a típus kiterjesztések, kulcs direktívák és az elosztott nyomkövetés.

Ez a cikk a Schema Stitchingre fókuszál, feltárva annak koncepcióit, előnyeit, korlátait és gyakorlati megvalósítását.

A Schema Stitching megértése

A Schema Stitching több GraphQL séma egyetlen, koherens sémává történő összefűzésének folyamata. Ez az egységes séma egy homlokzatként működik, elrejtve a mögöttes szolgáltatások bonyolultságát a kliens elől. Amikor egy kliens kérést küld az összefűzött sémához, az átjáró intelligensen továbbítja a kérést a megfelelő mögöttes szolgáltatás(ok)hoz, lekéri az adatokat, és az eredményeket egyesíti, mielőtt visszaküldené azokat a kliensnek.

Gondoljon rá úgy, mint: van több étterme (szolgáltatása), amelyek mind különböző konyhákra specializálódtak. A Schema Stitching olyan, mint egy univerzális étlap, amely az összes étterem összes fogását egyesíti. Amikor egy vendég (kliens) rendel az univerzális étlapról, a rendelést intelligensen a megfelelő éttermi konyhákba irányítják, az ételt elkészítik, majd egyetlen szállítmányként egyesítik a vendég számára.

A Schema Stitching kulcsfogalmai

• Távoli sémák (Remote Schemas): Ezek az egyes mögöttes szolgáltatások egyedi GraphQL sémái. Minden szolgáltatás a saját sémáját teszi közzé, amely meghatározza az általa biztosított adatokat és műveleteket.
• Átjáró (Gateway): Az átjáró a központi komponens, amely felelős a távoli sémák összefűzéséért és az egységes séma kliens felé történő közzétételéért. Fogadja a kliens kéréseket, továbbítja azokat a megfelelő szolgáltatásokhoz, és egyesíti az eredményeket.
• Sémaegyesítés (Schema Merging): Ez a folyamat, amelynek során a távoli sémákat egyetlen sémává kombinálják. Ez gyakran magában foglalja a típusok és mezők átnevezését a konfliktusok elkerülése érdekében, valamint a különböző sémák típusai közötti kapcsolatok meghatározását.
• Lekérdezés delegálása (Query Delegation): Amikor egy kliens kérést küld az összefűzött sémához, az átjárónak delegálnia kell a kérést a megfelelő mögöttes szolgáltatás(ok)hoz az adatok lekéréséhez. Ez magában foglalja a kliens lekérdezésének lefordítását egy olyan lekérdezésre, amelyet a távoli szolgáltatás megért.
• Eredmény-összesítés (Result Aggregation): Miután az átjáró lekérte az adatokat a mögöttes szolgáltatásokból, az eredményeket egyetlen válaszba kell összesítenie, amelyet vissza lehet küldeni a kliensnek. Ez gyakran magában foglalja az adatok átalakítását, hogy megfeleljenek az összefűzött séma szerkezetének.

A Schema Stitching előnyei

A Schema Stitching számos meggyőző előnyt kínál a mikroszolgáltatási architektúrát alkalmazó szervezetek számára:

• Egységes API: Egyetlen, következetes API-t biztosít a kliensek számára, egyszerűsítve az adathozzáférést és csökkentve annak szükségességét, hogy a kliensek közvetlenül több szolgáltatással lépjenek kapcsolatba. Ez tisztább és intuitívabb fejlesztői élményt eredményez.
• Csökkentett kliensoldali bonyolultság: A klienseknek csak az egységes sémával kell kommunikálniuk, ami megvédi őket a mögöttes mikroszolgáltatási architektúra bonyolultságától. Ez egyszerűsíti a kliensoldali fejlesztést és csökkenti a kliensen szükséges kód mennyiségét.
• Növelt skálázhatóság: Lehetővé teszi az egyes szolgáltatások egymástól független skálázását a specifikus igényeik alapján. Ez javítja a rendszer általános skálázhatóságát és rugalmasságát. Például egy nagy terhelésű felhasználói szolgáltatás skálázható anélkül, hogy ez hatással lenne más szolgáltatásokra, mint például a termékkatalógusra.
• Jobb karbantarthatóság: Elősegíti a modularitást és a felelősségi körök szétválasztását, megkönnyítve az egyes szolgáltatások karbantartását és fejlesztését. Egy szolgáltatáson végrehajtott változtatások kevésbé valószínű, hogy hatással lesznek más szolgáltatásokra.
• Fokozatos bevezetés: Növekményesen is megvalósítható, lehetővé téve a monolitikus architektúráról a mikroszolgáltatási architektúrára való fokozatos áttérést. Kezdheti a meglévő API-k összefűzésével, majd fokozatosan bonthatja le a monolitot kisebb szolgáltatásokra.

A Schema Stitching korlátai

Bár a Schema Stitching számos előnnyel jár, fontos tisztában lenni a korlátaival:

• Bonyolultság: A schema stitching megvalósítása és kezelése összetett lehet, különösen nagy és komplex rendszerekben. A gondos tervezés elengedhetetlen.
• Teljesítménytöbblet: Az átjáró némi teljesítménytöbbletet okoz a további indirekciós réteg, valamint a lekérdezések delegálásának és az eredmények összesítésének szükségessége miatt. A gondos optimalizálás kulcsfontosságú e többlet minimalizálásához.
• Sémakonfliktusok: Konfliktusok merülhetnek fel a különböző szolgáltatások sémáinak egyesítésekor, különösen, ha azonos típus- vagy mezőneveket használnak. Ez gondos sématervezést és potenciálisan a típusok és mezők átnevezését igényli.
• Korlátozott haladó funkciók: Az Apollo Föderációhoz képest a Schema Stitchingből hiányoznak bizonyos haladó funkciók, mint például a típus kiterjesztések és a kulcs direktívák, ami megnehezítheti a különböző sémák közötti típuskapcsolatok kezelését.
• Eszközök fejlettsége: A Schema Stitching körüli eszközök és ökoszisztéma nem olyan kiforrott, mint az Apollo Föderáció esetében. Ez megnehezítheti a hibakeresést és a problémamegoldást.

A Schema Stitching gyakorlati megvalósítása

Nézzünk meg egy egyszerűsített példát a Schema Stitching megvalósítására Node.js és a graphql-tools könyvtár (egy népszerű választás a schema stitchinghez) segítségével. Ez a példa két mikroszolgáltatást tartalmaz: egy Felhasználói Szolgáltatást (User Service) és egy Termék Szolgáltatást (Product Service).

1. A távoli sémák definiálása

Először definiálja a GraphQL sémákat mindkét távoli szolgáltatáshoz.

Felhasználói Szolgáltatás (user-service.js):

const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

Termék Szolgáltatás (product-service.js):

const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Idegen kulcs a Felhasználói Szolgáltatáshoz
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

2. Az átjáró szolgáltatás létrehozása

Most hozza létre az átjáró szolgáltatást, amely összefűzi a két sémát.

Átjáró Szolgáltatás (gateway.js):

const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Átjáró szerver fut a http://localhost:4000/graphql címen'));
}

main().catch(console.error);

3. A szolgáltatások futtatása

A Felhasználói Szolgáltatást és a Termék Szolgáltatást különböző portokon kell futtatnia. Például:

Felhasználói Szolgáltatás (4001-es port):

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('Felhasználói szolgáltatás fut a http://localhost:4001/graphql címen'));

Termék Szolgáltatás (4002-es port):

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Termék szolgáltatás fut a http://localhost:4002/graphql címen'));

4. Az összefűzött séma lekérdezése

Most már lekérdezheti az összefűzött sémát az átjárón keresztül (amely a 4000-es porton fut). Egy ehhez hasonló lekérdezést futtathat:

query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

Ez a lekérdezés lekéri a "101"-es azonosítójú terméket, és lekéri a hozzá tartozó felhasználót is a Felhasználói Szolgáltatásból, bemutatva, hogy a Schema Stitching hogyan teszi lehetővé az adatok lekérdezését több szolgáltatásból egyetlen kérésben.

Haladó Schema Stitching technikák

Az alapvető példán túl, íme néhány haladó technika, amelyekkel javíthatja a Schema Stitching implementációját:

• Séma delegálás: Ez lehetővé teszi, hogy egy lekérdezés részeit különböző szolgáltatásoknak delegálja a kért adatok alapján. Például delegálhatja a `User` típus feloldását a Felhasználói Szolgáltatásnak, és a `Product` típus feloldását a Termék Szolgáltatásnak.
• Séma átalakítás: Ez magában foglalja egy távoli szolgáltatás sémájának módosítását, mielőtt azt az egységes sémába fűznék. Ez hasznos lehet típusok és mezők átnevezésére, új mezők hozzáadására vagy meglévő mezők eltávolítására.
• Egyéni resolverek: Definiálhat egyéni resolvereket az átjáróban, hogy kezelje a komplex adatátalakításokat, vagy hogy több szolgáltatásból kérjen le adatokat és azokat egyetlen eredménybe kombinálja.
• Kontextus megosztása: Gyakran szükséges kontextusinformációkat, például hitelesítési tokeneket vagy felhasználói azonosítókat megosztani az átjáró és a távoli szolgáltatások között. Ezt a kontextusinformációk átadásával lehet elérni a lekérdezés delegálási folyamat részeként.
• Hibakezelés: Implementáljon robusztus hibakezelést a távoli szolgáltatásokban előforduló hibák elegáns kezelésére. Ez magában foglalhatja a hibák naplózását, felhasználóbarát hibaüzenetek visszaküldését vagy a sikertelen kérések újrapróbálását.

Választás a Schema Stitching és az Apollo Föderáció között

Bár a Schema Stitching egy életképes opció a GraphQL Föderációhoz, az Apollo Föderáció vált a népszerűbb választássá a fejlett funkciói és a jobb fejlesztői élmény miatt. Íme a két megközelítés összehasonlítása:

Funkció	Schema Stitching	Apollo Föderáció
Séma definíció	Meglévő GraphQL séma nyelvet használ	Deklaratív séma nyelvet használ direktívákkal
Lekérdezés tervezés	Manuális lekérdezés delegálást igényel	Automatikus lekérdezés tervezés az Apollo Gateway által
Típus kiterjesztések	Korlátozott támogatás	Beépített támogatás a típus kiterjesztésekhez
Kulcs direktívák	Nem támogatott	Az @key direktívát használja az entitások azonosítására
Elosztott nyomkövetés	Manuális implementációt igényel	Beépített támogatás az elosztott nyomkövetéshez
Eszközök és ökoszisztéma	Kevésbé kiforrott eszközök	Kiforrottabb eszközök és nagy közösség
Bonyolultság	Nagy rendszerekben bonyolult lehet kezelni	Nagy és komplex rendszerekhez tervezték

Mikor válassza a Schema Stitchinget:

• Már létező GraphQL szolgáltatásai vannak, és gyorsan szeretné őket egyesíteni.
• Egyszerű föderációs megoldásra van szüksége, és nincsenek szüksége haladó funkciókra.
• Korlátozott erőforrásai vannak, és el szeretné kerülni az Apollo Föderáció beállításával járó többletterheket.

Mikor válassza az Apollo Föderációt:

• Nagy és komplex rendszert épít több csapattal és szolgáltatással.
• Szüksége van haladó funkciókra, mint a típus kiterjesztések, kulcs direktívák és az elosztott nyomkövetés.
• Robusztusabb és skálázhatóbb föderációs megoldást szeretne.
• Előnyben részesíti a deklaratívabb és automatizáltabb megközelítést a föderációhoz.

Valós példák és használati esetek

Íme néhány valós példa arra, hogyan használható a GraphQL Föderáció, beleértve a Schema Stitchinget is:

• E-kereskedelmi platform: Egy e-kereskedelmi platform használhatja a GraphQL Föderációt több szolgáltatás adatainak egyesítésére, mint például egy termékkatalógus-szolgáltatás, egy felhasználói szolgáltatás, egy rendelési szolgáltatás és egy fizetési szolgáltatás. Ez lehetővé teszi a kliensek számára, hogy könnyedén lekérjék az összes információt, amire szükségük van a termékadatok, felhasználói profilok, rendelési előzmények és fizetési információk megjelenítéséhez.
• Közösségi média platform: Egy közösségi média platform használhatná a GraphQL Föderációt a felhasználói profilokat, bejegyzéseket, hozzászólásokat és kedveléseket kezelő szolgáltatások adatainak egyesítésére. Ez lehetővé teszi a kliensek számára, hogy hatékonyan lekérjék az összes információt, amely egy felhasználó profiljának, bejegyzéseinek, valamint az ezekhez kapcsolódó hozzászólásoknak és kedveléseknek a megjelenítéséhez szükséges.
• Pénzügyi szolgáltatási alkalmazás: Egy pénzügyi szolgáltatási alkalmazás használhatja a GraphQL Föderációt a számlákat, tranzakciókat és befektetéseket kezelő szolgáltatások adatainak egyesítésére. Ez lehetővé teszi a kliensek számára, hogy könnyen lekérjék az összes információt, amire szükségük van a számlaegyenlegek, tranzakciós előzmények és befektetési portfóliók megjelenítéséhez.
• Tartalomkezelő rendszer (CMS): Egy CMS kihasználhatja a GraphQL Föderációt különböző forrásokból származó adatok, például cikkek, képek, videók és felhasználók által generált tartalmak integrálására. Ez egységes API-t tesz lehetővé az összes, egy adott témához vagy szerzőhöz kapcsolódó tartalom lekéréséhez.
• Egészségügyi alkalmazás: Integrálja a páciensek adatait különböző rendszerekből, mint például az elektronikus egészségügyi nyilvántartások (EHR), laboreredmények és időpont-egyeztetések. Ez az orvosoknak egyetlen hozzáférési pontot kínál az átfogó páciensinformációkhoz.

A Schema Stitching bevált gyakorlatai

A sikeres Schema Stitching implementáció érdekében kövesse az alábbi bevált gyakorlatokat:

• Gondosan tervezze meg a sémát: Mielőtt elkezdené a sémák összefűzését, gondosan tervezze meg az egységes séma szerkezetét. Ez magában foglalja a különböző sémák közötti típusok kapcsolatainak meghatározását, a típusok és mezők átnevezését a konfliktusok elkerülése érdekében, valamint az általános adathozzáférési minták figyelembevételét.
• Használjon következetes elnevezési konvenciókat: Alkalmazzon következetes elnevezési konvenciókat a típusokra, mezőkre és műveletekre minden szolgáltatásban. Ez segít elkerülni a konfliktusokat és megkönnyíti az egységes séma megértését.
• Dokumentálja a sémát: Dokumentálja alaposan az egységes sémát, beleértve a típusok, mezők és műveletek leírását. Ez megkönnyíti a fejlesztők számára a séma megértését és használatát.
• Figyelje a teljesítményt: Figyelje az átjáró és a távoli szolgáltatások teljesítményét a teljesítmény-szűk keresztmetszetek azonosítása és kezelése érdekében. Használjon olyan eszközöket, mint az elosztott nyomkövetés, a kérések több szolgáltatáson keresztüli követésére.
• Implementáljon biztonságot: Implementáljon megfelelő biztonsági intézkedéseket az átjáró és a távoli szolgáltatások jogosulatlan hozzáféréssel szembeni védelme érdekében. Ez magában foglalhatja a hitelesítési és engedélyezési mechanizmusok használatát, valamint a bemeneti validálást és a kimeneti kódolást.
• Verziózza a sémát: Ahogy fejleszti a sémáit, verziózza őket megfelelően, hogy a kliensek továbbra is használhassák a séma régebbi verzióit anélkül, hogy hibát okoznának. Ez segít elkerülni a törő változtatásokat és biztosítja a visszamenőleges kompatibilitást.
• Automatizálja a telepítést: Automatizálja az átjáró és a távoli szolgáltatások telepítését, hogy a változtatások gyorsan és megbízhatóan telepíthetők legyenek. Ez segít csökkenteni a hibák kockázatát és javítja a rendszer általános agilitását.

Következtetés

A GraphQL Föderáció a Schema Stitchinggel hatékony megközelítést kínál az egységes API-k létrehozására több szolgáltatásból egy mikroszolgáltatási architektúrában. A központi koncepciók, előnyök, korlátok és megvalósítási technikák megértésével kihasználhatja a Schema Stitchinget az adathozzáférés egyszerűsítésére, a skálázhatóság javítására és a karbantarthatóság növelésére. Bár az Apollo Föderáció egy fejlettebb megoldásként jelent meg, a Schema Stitching továbbra is életképes opció egyszerűbb forgatókönyvek esetén, vagy meglévő GraphQL szolgáltatások integrálásakor. Gondosan mérlegelje specifikus igényeit és követelményeit, hogy kiválassza a szervezetének legmegfelelőbb megközelítést.